package metadata

generated: components: sinks: websocket_server: configuration: {
	acknowledgements: {
		description: """
			Controls how acknowledgements are handled for this sink.

			See [End-to-end Acknowledgements][e2e_acks] for more information on how event acknowledgement is handled.

			[e2e_acks]: https://vector.dev/docs/architecture/end-to-end-acknowledgements/
			"""
		required: false
		type: object: options: enabled: {
			description: """
				Controls whether or not end-to-end acknowledgements are enabled.

				When enabled for a sink, any source that supports end-to-end
				acknowledgements that is connected to that sink waits for events
				to be acknowledged by **all connected sinks** before acknowledging them at the source.

				Enabling or disabling acknowledgements at the sink level takes precedence over any global
				[`acknowledgements`][global_acks] configuration.

				[global_acks]: https://vector.dev/docs/reference/configuration/global-options/#acknowledgements
				"""
			required: false
			type: bool: {}
		}
	}
	address: {
		description: """
			The socket address to listen for connections on.

			This value _must_ include a port.
			"""
		required: true
		type: string: examples: ["0.0.0.0:80", "localhost:80"]
	}
	auth: {
		description: """
			Configuration of the authentication strategy for server mode sinks and sources.

			Use the HTTP authentication with HTTPS only. The authentication credentials are passed as an
			HTTP header without any additional encryption beyond what is provided by the transport itself.
			"""
		required: false
		type: object: options: {
			password: {
				description:   "The basic authentication password."
				relevant_when: "strategy = \"basic\""
				required:      true
				type: string: examples: ["${PASSWORD}", "password"]
			}
			source: {
				description:   "The VRL boolean expression."
				relevant_when: "strategy = \"custom\""
				required:      true
				type: string: {}
			}
			strategy: {
				description: "The authentication strategy to use."
				required:    true
				type: string: enum: {
					basic: """
						Basic authentication.

						The username and password are concatenated and encoded using [base64][base64].

						[base64]: https://en.wikipedia.org/wiki/Base64
						"""
					custom: """
						Custom authentication using VRL code.

						Takes in request and validates it using VRL code.
						"""
				}
			}
			username: {
				description:   "The basic authentication username."
				relevant_when: "strategy = \"basic\""
				required:      true
				type: string: examples: ["${USERNAME}", "username"]
			}
		}
	}
	encoding: {
		description: """
			Encoding configuration.
			Configures how events are encoded into raw bytes.
			The selected encoding also determines which input types (logs, metrics, traces) are supported.
			"""
		required: true
		type: object: options: {
			avro: {
				description:   "Apache Avro-specific encoder options."
				relevant_when: "codec = \"avro\""
				required:      true
				type: object: options: schema: {
					description: "The Avro schema."
					required:    true
					type: string: examples: ["{ \"type\": \"record\", \"name\": \"log\", \"fields\": [{ \"name\": \"message\", \"type\": \"string\" }] }"]
				}
			}
			cef: {
				description:   "The CEF Serializer Options."
				relevant_when: "codec = \"cef\""
				required:      true
				type: object: options: {
					device_event_class_id: {
						description: """
																Unique identifier for each event type. Identifies the type of event reported.
																The value length must be less than or equal to 1023.
																"""
						required: true
						type: string: {}
					}
					device_product: {
						description: """
																Identifies the product of a vendor.
																The part of a unique device identifier. No two products can use the same combination of device vendor and device product.
																The value length must be less than or equal to 63.
																"""
						required: true
						type: string: {}
					}
					device_vendor: {
						description: """
																Identifies the vendor of the product.
																The part of a unique device identifier. No two products can use the same combination of device vendor and device product.
																The value length must be less than or equal to 63.
																"""
						required: true
						type: string: {}
					}
					device_version: {
						description: """
																Identifies the version of the problem. The combination of the device product, vendor, and this value make up the unique id of the device that sends messages.
																The value length must be less than or equal to 31.
																"""
						required: true
						type: string: {}
					}
					extensions: {
						description: """
																The collection of key-value pairs. Keys are the keys of the extensions, and values are paths that point to the extension values of a log event.
																The event can have any number of key-value pairs in any order.
																"""
						required: false
						type: object: options: "*": {
							description: "This is a path that points to the extension value of a log event."
							required:    true
							type: string: {}
						}
					}
					name: {
						description: """
																This is a path that points to the human-readable description of a log event.
																The value length must be less than or equal to 512.
																Equals "cef.name" by default.
																"""
						required: true
						type: string: {}
					}
					severity: {
						description: """
																This is a path that points to the field of a log event that reflects importance of the event.

																It must point to a number from 0 to 10.
																0 = lowest_importance, 10 = highest_importance.
																Set to "cef.severity" by default.
																"""
						required: true
						type: string: {}
					}
					version: {
						description: """
																CEF Version. Can be either 0 or 1.
																Set to "0" by default.
																"""
						required: true
						type: string: enum: {
							V0: "CEF specification version 0.1."
							V1: "CEF specification version 1.x."
						}
					}
				}
			}
			codec: {
				description: "The codec to use for encoding events."
				required:    true
				type: string: enum: {
					avro: """
						Encodes an event as an [Apache Avro][apache_avro] message.

						[apache_avro]: https://avro.apache.org/
						"""
					cef: "Encodes an event as a CEF (Common Event Format) formatted message."
					csv: """
						Encodes an event as a CSV message.

						This codec must be configured with fields to encode.
						"""
					gelf: """
						Encodes an event as a [GELF][gelf] message.

						This codec is experimental for the following reason:

						The GELF specification is more strict than the actual Graylog receiver.
						Vector's encoder currently adheres more strictly to the GELF spec, with
						the exception that some characters such as `@`  are allowed in field names.

						Other GELF codecs, such as Loki's, use a [Go SDK][implementation] that is maintained
						by Graylog and is much more relaxed than the GELF spec.

						Going forward, Vector will use that [Go SDK][implementation] as the reference implementation, which means
						the codec might continue to relax the enforcement of the specification.

						[gelf]: https://docs.graylog.org/docs/gelf
						[implementation]: https://github.com/Graylog2/go-gelf/blob/v2/gelf/reader.go
						"""
					json: """
						Encodes an event as [JSON][json].

						[json]: https://www.json.org/
						"""
					logfmt: """
						Encodes an event as a [logfmt][logfmt] message.

						[logfmt]: https://brandur.org/logfmt
						"""
					native: """
						Encodes an event in the [native Protocol Buffers format][vector_native_protobuf].

						This codec is **[experimental][experimental]**.

						[vector_native_protobuf]: https://github.com/vectordotdev/vector/blob/master/lib/vector-core/proto/event.proto
						[experimental]: https://vector.dev/highlights/2022-03-31-native-event-codecs
						"""
					native_json: """
						Encodes an event in the [native JSON format][vector_native_json].

						This codec is **[experimental][experimental]**.

						[vector_native_json]: https://github.com/vectordotdev/vector/blob/master/lib/codecs/tests/data/native_encoding/schema.cue
						[experimental]: https://vector.dev/highlights/2022-03-31-native-event-codecs
						"""
					otlp: """
						Encodes an event in the [OTLP (OpenTelemetry Protocol)][otlp] format.

						This codec uses protobuf encoding, which is the recommended format for OTLP.
						The output is suitable for sending to OTLP-compatible endpoints with
						`content-type: application/x-protobuf`.

						[otlp]: https://opentelemetry.io/docs/specs/otlp/
						"""
					protobuf: """
						Encodes an event as a [Protobuf][protobuf] message.

						[protobuf]: https://protobuf.dev/
						"""
					raw_message: """
						No encoding.

						This encoding uses the `message` field of a log event.

						Be careful if you are modifying your log events (for example, by using a `remap`
						transform) and removing the message field while doing additional parsing on it, as this
						could lead to the encoding emitting empty strings for the given event.
						"""
					text: """
						Plain text encoding.

						This encoding uses the `message` field of a log event. For metrics, it uses an
						encoding that resembles the Prometheus export format.

						Be careful if you are modifying your log events (for example, by using a `remap`
						transform) and removing the message field while doing additional parsing on it, as this
						could lead to the encoding emitting empty strings for the given event.
						"""
				}
			}
			csv: {
				description:   "The CSV Serializer Options."
				relevant_when: "codec = \"csv\""
				required:      true
				type: object: options: {
					capacity: {
						description: """
																Sets the capacity (in bytes) of the internal buffer used in the CSV writer.
																This defaults to 8192 bytes (8KB).
																"""
						required: false
						type: uint: default: 8192
					}
					delimiter: {
						description: "The field delimiter to use when writing CSV."
						required:    false
						type: ascii_char: default: ","
					}
					double_quote: {
						description: """
																Enables double quote escapes.

																This is enabled by default, but you can disable it. When disabled, quotes in
																field data are escaped instead of doubled.
																"""
						required: false
						type: bool: default: true
					}
					escape: {
						description: """
																The escape character to use when writing CSV.

																In some variants of CSV, quotes are escaped using a special escape character
																like \\ (instead of escaping quotes by doubling them).

																To use this, `double_quotes` needs to be disabled as well; otherwise, this setting is ignored.
																"""
						required: false
						type: ascii_char: default: "\""
					}
					fields: {
						description: """
																Configures the fields that are encoded, as well as the order in which they
																appear in the output.

																If a field is not present in the event, the output for that field is an empty string.

																Values of type `Array`, `Object`, and `Regex` are not supported, and the
																output for any of these types is an empty string.
																"""
						required: true
						type: array: items: type: string: {}
					}
					quote: {
						description: "The quote character to use when writing CSV."
						required:    false
						type: ascii_char: default: "\""
					}
					quote_style: {
						description: "The quoting style to use when writing CSV data."
						required:    false
						type: string: {
							default: "necessary"
							enum: {
								always: "Always puts quotes around every field."
								necessary: """
																			Puts quotes around fields only when necessary.
																			They are necessary when fields contain a quote, delimiter, or record terminator.
																			Quotes are also necessary when writing an empty record
																			(which is indistinguishable from a record with one empty field).
																			"""
								never: "Never writes quotes, even if it produces invalid CSV data."
								non_numeric: """
																			Puts quotes around all fields that are non-numeric.
																			This means that when writing a field that does not parse as a valid float or integer,
																			quotes are used even if they aren't strictly necessary.
																			"""
							}
						}
					}
				}
			}
			except_fields: {
				description: "List of fields that are excluded from the encoded event."
				required:    false
				type: array: items: type: string: {}
			}
			gelf: {
				description:   "The GELF Serializer Options."
				relevant_when: "codec = \"gelf\""
				required:      false
				type: object: options: max_chunk_size: {
					description: """
						Maximum size for each GELF chunked datagram (including 12-byte header).
						Chunking starts when datagrams exceed this size.
						For Graylog target, keep at or below 8192 bytes; for Vector target (`gelf` decoding with `chunked_gelf` framing), up to 65,500 bytes is recommended.
						"""
					required: false
					type: uint: default: 8192
				}
			}
			json: {
				description:   "Options for the JsonSerializer."
				relevant_when: "codec = \"json\""
				required:      false
				type: object: options: pretty: {
					description: "Whether to use pretty JSON formatting."
					required:    false
					type: bool: default: false
				}
			}
			metric_tag_values: {
				description: """
					Controls how metric tag values are encoded.

					When set to `single`, only the last non-bare value of tags are displayed with the
					metric. When set to `full`, all metric tags are exposed as separate assignments.
					"""
				relevant_when: "codec = \"json\" or codec = \"text\""
				required:      false
				type: string: {
					default: "single"
					enum: {
						full: "All tags are exposed as arrays of either string or null values."
						single: """
															Tag values are exposed as single strings, the same as they were before this config
															option. Tags with multiple values show the last assigned value, and null values
															are ignored.
															"""
					}
				}
			}
			only_fields: {
				description: "List of fields that are included in the encoded event."
				required:    false
				type: array: items: type: string: {}
			}
			protobuf: {
				description:   "Options for the Protobuf serializer."
				relevant_when: "codec = \"protobuf\""
				required:      true
				type: object: options: {
					desc_file: {
						description: """
																The path to the protobuf descriptor set file.

																This file is the output of `protoc -I <include path> -o <desc output path> <proto>`

																You can read more [here](https://buf.build/docs/reference/images/#how-buf-images-work).
																"""
						required: true
						type: string: examples: ["/etc/vector/protobuf_descriptor_set.desc"]
					}
					message_type: {
						description: "The name of the message type to use for serializing."
						required:    true
						type: string: examples: ["package.Message"]
					}
					use_json_names: {
						description: """
																Use JSON field names (camelCase) instead of protobuf field names (snake_case).

																When enabled, the serializer looks for fields using their JSON names as defined
																in the `.proto` file (for example `jobDescription` instead of `job_description`).

																This is useful when working with data that has already been converted from JSON or
																when interfacing with systems that use JSON naming conventions.
																"""
						required: false
						type: bool: default: false
					}
				}
			}
			timestamp_format: {
				description: "Format used for timestamp fields."
				required:    false
				type: string: enum: {
					rfc3339:    "Represent the timestamp as a RFC 3339 timestamp."
					unix:       "Represent the timestamp as a Unix timestamp."
					unix_float: "Represent the timestamp as a Unix timestamp in floating point."
					unix_ms:    "Represent the timestamp as a Unix timestamp in milliseconds."
					unix_ns:    "Represent the timestamp as a Unix timestamp in nanoseconds."
					unix_us:    "Represent the timestamp as a Unix timestamp in microseconds."
				}
			}
		}
	}
	internal_metrics: {
		description: "Configuration of internal metrics"
		required:    false
		type: object: options: extra_tags: {
			description: "Extra tags to add to all metrics generated by this component"
			required:    false
			type: object: options: "*": {
				description: "Maps extra tag keys to values."
				required:    true
				type: object: options: {
					name: {
						description:   "Name of the header to use as value"
						relevant_when: "type = \"header\" or type = \"query\""
						required:      true
						type: string: {}
					}
					type: {
						description: "Enum for extra metric tag values."
						required:    true
						type: string: enum: {
							fixed:      "Hard-coded extra metric tag for all clients"
							header:     "Extra metric tag that takes on the value of a header"
							ip_address: "Extra metric tag that uses client ip address as value"
							query:      "Extra metric tag that takes on the value of a query parameter"
							url:        "Extra metric tag that takes full request URL as value"
						}
					}
					value: {
						description:   "Tag value"
						relevant_when: "type = \"fixed\""
						required:      true
						type: string: {}
					}
					with_port: {
						description: """
																				Set to true if port should be included with the ip address.

																				By default port is not included
																				"""
						relevant_when: "type = \"ip_address\""
						required:      false
						type: bool: default: false
					}
				}
			}
		}
	}
	message_buffering: {
		description: "Configuration for message buffering which enables message replay for clients that connect later."
		required:    false
		type: object: options: {
			client_ack_config: {
				description: """
					Configuration for ACK support for message buffering.
					Enabling ACK support makes it possible to replay messages for clients without requiring query
					parameters at connection time. It moves the burden of tracking latest received messages from
					clients to this component. It requires clients to respond to received messages with an ACK.
					"""
				required: false
				type: object: options: {
					ack_decoding: {
						description: """
																Configures how events are decoded from raw bytes. Note some decoders can also determine the event output
																type (log, metric, trace).
																"""
						required: false
						type: object: options: {
							avro: {
								description:   "Apache Avro-specific encoder options."
								relevant_when: "codec = \"avro\""
								required:      true
								type: object: options: {
									schema: {
										description: """
																								The Avro schema definition.
																								**Note**: The following [`apache_avro::types::Value`] variants are *not* supported:
																								* `Date`
																								* `Decimal`
																								* `Duration`
																								* `Fixed`
																								* `TimeMillis`
																								"""
										required: true
										type: string: examples: ["{ \"type\": \"record\", \"name\": \"log\", \"fields\": [{ \"name\": \"message\", \"type\": \"string\" }] }"]
									}
									strip_schema_id_prefix: {
										description: """
																								For Avro datum encoded in Kafka messages, the bytes are prefixed with the schema ID.  Set this to `true` to strip the schema ID prefix.
																								According to [Confluent Kafka's document](https://docs.confluent.io/platform/current/schema-registry/fundamentals/serdes-develop/index.html#wire-format).
																								"""
										required: true
										type: bool: {}
									}
								}
							}
							codec: {
								description: "The codec to use for decoding events."
								required:    false
								type: string: {
									default: "bytes"
									enum: {
										avro: """
																							Decodes the raw bytes as as an [Apache Avro][apache_avro] message.

																							[apache_avro]: https://avro.apache.org/
																							"""
										bytes: "Uses the raw bytes as-is."
										gelf: """
																							Decodes the raw bytes as a [GELF][gelf] message.

																							This codec is experimental for the following reason:

																							The GELF specification is more strict than the actual Graylog receiver.
																							Vector's decoder adheres more strictly to the GELF spec, with
																							the exception that some characters such as `@`  are allowed in field names.

																							Other GELF codecs such as Loki's, use a [Go SDK][implementation] that is maintained
																							by Graylog, and is much more relaxed than the GELF spec.

																							Going forward, Vector will use that [Go SDK][implementation] as the reference implementation, which means
																							the codec may continue to relax the enforcement of specification.

																							[gelf]: https://docs.graylog.org/docs/gelf
																							[implementation]: https://github.com/Graylog2/go-gelf/blob/v2/gelf/reader.go
																							"""
										influxdb: """
																							Decodes the raw bytes as an [Influxdb Line Protocol][influxdb] message.

																							[influxdb]: https://docs.influxdata.com/influxdb/cloud/reference/syntax/line-protocol
																							"""
										json: """
																							Decodes the raw bytes as [JSON][json].

																							[json]: https://www.json.org/
																							"""
										native: """
																							Decodes the raw bytes as [native Protocol Buffers format][vector_native_protobuf].

																							This decoder can output all types of events (logs, metrics, traces).

																							This codec is **[experimental][experimental]**.

																							[vector_native_protobuf]: https://github.com/vectordotdev/vector/blob/master/lib/vector-core/proto/event.proto
																							[experimental]: https://vector.dev/highlights/2022-03-31-native-event-codecs
																							"""
										native_json: """
																							Decodes the raw bytes as [native JSON format][vector_native_json].

																							This decoder can output all types of events (logs, metrics, traces).

																							This codec is **[experimental][experimental]**.

																							[vector_native_json]: https://github.com/vectordotdev/vector/blob/master/lib/codecs/tests/data/native_encoding/schema.cue
																							[experimental]: https://vector.dev/highlights/2022-03-31-native-event-codecs
																							"""
										otlp: """
																							Decodes the raw bytes as [OTLP (OpenTelemetry Protocol)][otlp] protobuf format.

																							This decoder handles the three OTLP signal types: logs, metrics, and traces.
																							It automatically detects which type of OTLP message is being decoded.

																							[otlp]: https://opentelemetry.io/docs/specs/otlp/
																							"""
										protobuf: """
																							Decodes the raw bytes as [protobuf][protobuf].

																							[protobuf]: https://protobuf.dev/
																							"""
										syslog: """
																							Decodes the raw bytes as a Syslog message.

																							Decodes either as the [RFC 3164][rfc3164]-style format ("old" style) or the
																							[RFC 5424][rfc5424]-style format ("new" style, includes structured data).

																							[rfc3164]: https://www.ietf.org/rfc/rfc3164.txt
																							[rfc5424]: https://www.ietf.org/rfc/rfc5424.txt
																							"""
										vrl: """
																							Decodes the raw bytes as a string and passes them as input to a [VRL][vrl] program.

																							[vrl]: https://vector.dev/docs/reference/vrl
																							"""
									}
								}
							}
							gelf: {
								description:   "GELF-specific decoding options."
								relevant_when: "codec = \"gelf\""
								required:      false
								type: object: options: {
									lossy: {
										description: """
																								Determines whether to replace invalid UTF-8 sequences instead of failing.

																								When true, invalid UTF-8 sequences are replaced with the [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].

																								[U+FFFD]: https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character
																								"""
										required: false
										type: bool: default: true
									}
									validation: {
										description: "Configures the decoding validation mode."
										required:    false
										type: string: {
											default: "strict"
											enum: {
												relaxed: """
																											Uses more relaxed validation that skips strict GELF specification checks.

																											This mode will not treat specification violations as errors, allowing the decoder
																											to accept messages from sources that don't strictly follow the GELF spec.
																											"""
												strict: "Uses strict validation that closely follows the GELF spec."
											}
										}
									}
								}
							}
							influxdb: {
								description:   "Influxdb-specific decoding options."
								relevant_when: "codec = \"influxdb\""
								required:      false
								type: object: options: lossy: {
									description: """
																								Determines whether to replace invalid UTF-8 sequences instead of failing.

																								When true, invalid UTF-8 sequences are replaced with the [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].

																								[U+FFFD]: https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character
																								"""
									required: false
									type: bool: default: true
								}
							}
							json: {
								description:   "JSON-specific decoding options."
								relevant_when: "codec = \"json\""
								required:      false
								type: object: options: lossy: {
									description: """
																								Determines whether to replace invalid UTF-8 sequences instead of failing.

																								When true, invalid UTF-8 sequences are replaced with the [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].

																								[U+FFFD]: https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character
																								"""
									required: false
									type: bool: default: true
								}
							}
							native_json: {
								description:   "Vector's native JSON-specific decoding options."
								relevant_when: "codec = \"native_json\""
								required:      false
								type: object: options: lossy: {
									description: """
																								Determines whether to replace invalid UTF-8 sequences instead of failing.

																								When true, invalid UTF-8 sequences are replaced with the [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].

																								[U+FFFD]: https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character
																								"""
									required: false
									type: bool: default: true
								}
							}
							protobuf: {
								description:   "Protobuf-specific decoding options."
								relevant_when: "codec = \"protobuf\""
								required:      false
								type: object: options: {
									desc_file: {
										description: """
																								The path to the protobuf descriptor set file.

																								This file is the output of `protoc -I <include path> -o <desc output path> <proto>`.

																								You can read more [here](https://buf.build/docs/reference/images/#how-buf-images-work).
																								"""
										required: false
										type: string: default: ""
									}
									message_type: {
										description: "The name of the message type to use for serializing."
										required:    false
										type: string: {
											default: ""
											examples: ["package.Message"]
										}
									}
									use_json_names: {
										description: """
																								Use JSON field names (camelCase) instead of protobuf field names (snake_case).

																								When enabled, the deserializer will output fields using their JSON names as defined
																								in the `.proto` file (e.g., `jobDescription` instead of `job_description`).

																								This is useful when working with data that needs to be converted to JSON or
																								when interfacing with systems that use JSON naming conventions.
																								"""
										required: false
										type: bool: default: false
									}
								}
							}
							signal_types: {
								description: """
																				Signal types to attempt parsing, in priority order.

																				The deserializer will try parsing in the order specified. This allows you to optimize
																				performance when you know the expected signal types. For example, if you only receive
																				traces, set this to `["traces"]` to avoid attempting to parse as logs or metrics first.

																				If not specified, defaults to trying all types in order: logs, metrics, traces.
																				Duplicate signal types are automatically removed while preserving order.
																				"""
								relevant_when: "codec = \"otlp\""
								required:      false
								type: array: {
									default: ["logs", "metrics", "traces"]
									items: type: string: enum: {
										logs:    "OTLP logs signal (ExportLogsServiceRequest)"
										metrics: "OTLP metrics signal (ExportMetricsServiceRequest)"
										traces:  "OTLP traces signal (ExportTraceServiceRequest)"
									}
								}
							}
							syslog: {
								description:   "Syslog-specific decoding options."
								relevant_when: "codec = \"syslog\""
								required:      false
								type: object: options: lossy: {
									description: """
																								Determines whether to replace invalid UTF-8 sequences instead of failing.

																								When true, invalid UTF-8 sequences are replaced with the [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].

																								[U+FFFD]: https://en.wikipedia.org/wiki/Specials_(Unicode_block)#Replacement_character
																								"""
									required: false
									type: bool: default: true
								}
							}
							vrl: {
								description:   "VRL-specific decoding options."
								relevant_when: "codec = \"vrl\""
								required:      true
								type: object: options: {
									source: {
										description: """
																								The [Vector Remap Language][vrl] (VRL) program to execute for each event.
																								Note that the final contents of the `.` target will be used as the decoding result.
																								Compilation error or use of 'abort' in a program will result in a decoding error.

																								[vrl]: https://vector.dev/docs/reference/vrl
																								"""
										required: true
										type: string: {}
									}
									timezone: {
										description: """
																								The name of the timezone to apply to timestamp conversions that do not contain an explicit
																								time zone. The time zone name may be any name in the [TZ database][tz_database], or `local`
																								to indicate system local time.

																								If not set, `local` is used.

																								[tz_database]: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
																								"""
										required: false
										type: string: examples: ["local", "America/New_York", "EST5EDT"]
									}
								}
							}
						}
					}
					client_key: {
						description: "Configuration for client key used for tracking ACKed message for message buffering."
						required:    false
						type: object: options: {
							name: {
								description:   "Name of the header to use as value"
								relevant_when: "type = \"header\""
								required:      true
								type: string: {}
							}
							type: {
								description: "The type of client key to use, when tracking ACKed message for message buffering."
								required:    false
								type: string: {
									default: "ip_address"
									enum: {
										header:     "Use the value of a header on connection request as the unique key for that client"
										ip_address: "Use client IP address as the unique key for that client"
									}
								}
							}
							with_port: {
								description: """
																				Set to true if port should be included with the IP address

																				By default port is not included
																				"""
								relevant_when: "type = \"ip_address\""
								required:      false
								type: bool: default: false
							}
						}
					}
					message_id_path: {
						description: """
																Name of the field that contains the ACKed message ID. Use "." if message ID is the root of
																the message.
																"""
						required: true
						type: string: {}
					}
				}
			}
			max_events: {
				description: """
					Max events to hold in buffer.

					The buffer is backed by a ring buffer, so the oldest messages will be lost when the size
					limit is reached.
					"""
				required: false
				type: uint: default: 1000
			}
			message_id_path: {
				description: """
					Message ID path.

					This has to be defined to expose message ID to clients in the messages. Using that ID,
					clients can request replay starting from the message ID of their choosing.
					"""
				required: false
				type: string: {}
			}
		}
	}
	subprotocol: {
		description: "Configuration of websocket subprotocol handling."
		required:    false
		type: object: options: {
			supported_subprotocols: {
				description: """
					List of supported `Sec-WebSocket-Protocol` values. First match out of requested
					subprotocols will be accepted.
					"""
				relevant_when: "type = \"specific\""
				required:      false
				type: array: {
					default: []
					items: type: string: {}
				}
			}
			type: {
				description: "Enum for websocket subprotocol handling."
				required:    false
				type: string: {
					default: "specific"
					enum: {
						any: "Supports any subprotocol that the client sends. First of the requested subprotocols will be accepted."
						specific: """
															Supports only listed subprotocols. If client doesn't send any of these, server will skip
															`Sec-WebSocket-Protocol` header and the client can choose to close the connection then.
															"""
					}
				}
			}
		}
	}
	tls: {
		description: "Configures the TLS options for incoming/outgoing connections."
		required:    false
		type: object: options: {
			alpn_protocols: {
				description: """
					Sets the list of supported ALPN protocols.

					Declare the supported ALPN protocols, which are used during negotiation with a peer. They are prioritized in the order
					that they are defined.
					"""
				required: false
				type: array: items: type: string: examples: ["h2"]
			}
			ca_file: {
				description: """
					Absolute path to an additional CA certificate file.

					The certificate must be in the DER or PEM (X.509) format. Additionally, the certificate can be provided as an inline string in PEM format.
					"""
				required: false
				type: string: examples: ["/path/to/certificate_authority.crt"]
			}
			crt_file: {
				description: """
					Absolute path to a certificate file used to identify this server.

					The certificate must be in DER, PEM (X.509), or PKCS#12 format. Additionally, the certificate can be provided as
					an inline string in PEM format.

					If this is set _and_ is not a PKCS#12 archive, `key_file` must also be set.
					"""
				required: false
				type: string: examples: ["/path/to/host_certificate.crt"]
			}
			enabled: {
				description: """
					Whether to require TLS for incoming or outgoing connections.

					When enabled and used for incoming connections, an identity certificate is also required. See `tls.crt_file` for
					more information.
					"""
				required: false
				type: bool: {}
			}
			key_file: {
				description: """
					Absolute path to a private key file used to identify this server.

					The key must be in DER or PEM (PKCS#8) format. Additionally, the key can be provided as an inline string in PEM format.
					"""
				required: false
				type: string: examples: ["/path/to/host_certificate.key"]
			}
			key_pass: {
				description: """
					Passphrase used to unlock the encrypted key file.

					This has no effect unless `key_file` is set.
					"""
				required: false
				type: string: examples: ["${KEY_PASS_ENV_VAR}", "PassWord1"]
			}
			server_name: {
				description: """
					Server name to use when using Server Name Indication (SNI).

					Only relevant for outgoing connections.
					"""
				required: false
				type: string: examples: ["www.example.com"]
			}
			verify_certificate: {
				description: """
					Enables certificate verification. For components that create a server, this requires that the
					client connections have a valid client certificate. For components that initiate requests,
					this validates that the upstream has a valid certificate.

					If enabled, certificates must not be expired and must be issued by a trusted
					issuer. This verification operates in a hierarchical manner, checking that the leaf certificate (the
					certificate presented by the client/server) is not only valid, but that the issuer of that certificate is also valid, and
					so on, until the verification process reaches a root certificate.

					Do NOT set this to `false` unless you understand the risks of not verifying the validity of certificates.
					"""
				required: false
				type: bool: {}
			}
			verify_hostname: {
				description: """
					Enables hostname verification.

					If enabled, the hostname used to connect to the remote host must be present in the TLS certificate presented by
					the remote host, either as the Common Name or as an entry in the Subject Alternative Name extension.

					Only relevant for outgoing connections.

					Do NOT set this to `false` unless you understand the risks of not verifying the remote hostname.
					"""
				required: false
				type: bool: {}
			}
		}
	}
}
